Basic AeSdk class implements:

  • node selector,
  • integrated compiler support,
  • wrappers of account methods mapped to the current account.

Hierarchy

Constructors

Properties

_getPollInterval: ((...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => number)

Type declaration

    • (...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): number
    • Parameters

      • Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns number

_options: AeSdkMethodsOptions = ...
accounts: {
    [key: AccountAddress]: AccountBase;
} = {}

Type declaration

aensBid: ((...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

    • (...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<AensClaimReturnType>
    • Parameters

      • Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<AensClaimReturnType>

aensClaim: ((...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

aensPreclaim: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<SendReturnType & {
    claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
    commitmentId: string;
    height: number;
    salt: number;
}>>)

Type declaration

aensQuery: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
} & {
    extendTtl: ((nameTtl: number, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    id: `nm_${string}`;
    owner: `ak_${string}`;
    pointers: NamePointer[] | KeyPointers;
    revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType>);
    transfer: ((account: `ak_${string}`, options?: {
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    ttl: number;
    update: ((pointers: KeyPointers, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
}>>)

Type declaration

    • (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & {
          extendTtl: ((nameTtl: number, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          id: `nm_${string}`;
          owner: `ak_${string}`;
          pointers: NamePointer[] | KeyPointers;
          revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType>);
          transfer: ((account: `ak_${string}`, options?: {
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          ttl: number;
          update: ((pointers: KeyPointers, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      }>>
    • Parameters

      Returns Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & {
          extendTtl: ((nameTtl: number, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          id: `nm_${string}`;
          owner: `ak_${string}`;
          pointers: NamePointer[] | KeyPointers;
          revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType>);
          transfer: ((account: `ak_${string}`, options?: {
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
          ttl: number;
          update: ((pointers: KeyPointers, options?: Omit<{
              onNode: Node;
          } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
              onAccount?: AccountBase;
          }) => Promise<SendReturnType> & Promise<Readonly<{
              id: string;
              owner?: string;
              pointers: ({ key: string; id: string; })[];
              ttl: number;
          } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      }>>

aensRevoke: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

aensTransfer: ((...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>
    • Parameters

      • Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

aensUpdate: ((...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

awaitHeight: ((...args: [number] | [number, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [number] | [number, Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>
    • Parameters

      • Rest ...args: [number] | [number, Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

buildAuthTxHash: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Uint8Array>)

Type declaration

    • (...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Uint8Array>
    • Parameters

      • Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<Uint8Array>

createGeneralizedAccount: ((...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    gaContractId: `ct_${string}`;
    owner: `ak_${string}`;
    rawTx: `tx_${string}`;
    transaction: `th_${string}`;
}>>)

Type declaration

    • (...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<Readonly<{
          gaContractId: `ct_${string}`;
          owner: `ak_${string}`;
          rawTx: `tx_${string}`;
          transaction: `th_${string}`;
      }>>
    • Parameters

      Returns Promise<Readonly<{
          gaContractId: `ct_${string}`;
          owner: `ak_${string}`;
          rawTx: `tx_${string}`;
          transaction: `th_${string}`;
      }>>

extendOracleTtl: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

getAccount: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    authFun?: string;
    balance: bigint;
    contractId?: string;
    id: string;
    kind?: AccountKind;
    nonce: number;
    payable?: boolean;
}>)

Type declaration

    • (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          authFun?: string;
          balance: bigint;
          contractId?: string;
          id: string;
          kind?: AccountKind;
          nonce: number;
          payable?: boolean;
      }>
    • Parameters

      • Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
            hash?: `kh_${string}` | `mh_${string}`;
            height?: number;
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          authFun?: string;
          balance: bigint;
          contractId?: string;
          id: string;
          kind?: AccountKind;
          nonce: number;
          payable?: boolean;
      }>

getBalance: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    format?: AE_AMOUNT_FORMATS;
} & {
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

    • (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
          format?: AE_AMOUNT_FORMATS;
      } & {
          hash?: `kh_${string}` | `mh_${string}`;
          height?: number;
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<string>
    • Parameters

      • Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
            format?: AE_AMOUNT_FORMATS;
        } & {
            hash?: `kh_${string}` | `mh_${string}`;
            height?: number;
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<string>

getContract: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    abiVersion: string;
    active: boolean;
    deposit: bigint;
    id: string;
    ownerId: string;
    referrerIds: string[];
    vmVersion: string;
}>)

Type declaration

    • (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          abiVersion: string;
          active: boolean;
          deposit: bigint;
          id: string;
          ownerId: string;
          referrerIds: string[];
          vmVersion: string;
      }>
    • Parameters

      • Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          abiVersion: string;
          active: boolean;
          deposit: bigint;
          id: string;
          ownerId: string;
          referrerIds: string[];
          vmVersion: string;
      }>

getContractByteCode: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    bytecode: `cb_${string}`;
}>)

Type declaration

    • (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          bytecode: `cb_${string}`;
      }>
    • Parameters

      • Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          bytecode: `cb_${string}`;
      }>

getCurrentGeneration: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

    • (...args: [] | [Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>
    • Parameters

      • Rest ...args: [] | [Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

getGeneration: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

    • (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>
    • Parameters

      • Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
          microBlocks: string[];
      }>

getHeight: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [] | [Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>
    • Parameters

      • Rest ...args: [] | [Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

getKeyBlock: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    beneficiary: string;
    hash: string;
    height: number;
    info: string;
    miner: string;
    nonce?: number;
    pow?: string[];
    prevHash: string;
    prevKeyHash: string;
    stateHash: string;
    target: string;
    time: number;
    version: number;
}>)

Type declaration

    • (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          beneficiary: string;
          hash: string;
          height: number;
          info: string;
          miner: string;
          nonce?: number;
          pow?: string[];
          prevHash: string;
          prevKeyHash: string;
          stateHash: string;
          target: string;
          time: number;
          version: number;
      }>
    • Parameters

      • Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          beneficiary: string;
          hash: string;
          height: number;
          info: string;
          miner: string;
          nonce?: number;
          pow?: string[];
          prevHash: string;
          prevKeyHash: string;
          stateHash: string;
          target: string;
          time: number;
          version: number;
      }>

getMicroBlockHeader: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    hash: string;
    height: number;
    pofHash: string;
    prevHash: string;
    prevKeyHash: string;
    signature: string;
    stateHash: string;
    time: number;
    txsHash: string;
    version: number;
}>)

Type declaration

    • (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          hash: string;
          height: number;
          pofHash: string;
          prevHash: string;
          prevKeyHash: string;
          signature: string;
          stateHash: string;
          time: number;
          txsHash: string;
          version: number;
      }>
    • Parameters

      • Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          hash: string;
          height: number;
          pofHash: string;
          prevHash: string;
          prevKeyHash: string;
          signature: string;
          stateHash: string;
          time: number;
          txsHash: string;
          version: number;
      }>

getMicroBlockTransactions: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}[]>)

Type declaration

    • (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }[]>
    • Parameters

      • Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }[]>

getName: ((...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
}>)

Type declaration

    • (...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
          onNode: Node;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      }>
    • Parameters

      • Rest ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
            onNode: Node;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      }>

getOracleObject: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
    onAccount: AccountBase;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetOracleObjectReturnType>)

Type declaration

getQueryObject: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetQueryObjectReturnType>)

Type declaration

    • (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<GetQueryObjectReturnType>
    • Parameters

      • Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<GetQueryObjectReturnType>

payForTransaction: ((...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

poll: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    blocks?: number;
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}>)

Type declaration

    • (...args: [`th_${string}`] | [`th_${string}`, Omit<{
          blocks?: number;
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }>
    • Parameters

      • Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
            blocks?: number;
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          blockHash: string;
          blockHeight: number;
          hash: string;
          signatures: string[];
          tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
      }>

pollForQueries: ((...args: [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void)] | [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void), Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => (() => void))

Type declaration

    • (...args: [`ok_${string}`, ((queries: {
          fee: bigint;
          id: string;
          oracleId: string;
          query: string;
          response: string;
          responseTtl: { type: TTLType; value: string; };
          senderId: string;
          senderNonce: string;
          ttl: number;
      }[]) => void)] | [`ok_${string}`, ((queries: {
          fee: bigint;
          id: string;
          oracleId: string;
          query: string;
          response: string;
          responseTtl: { type: TTLType; value: string; };
          senderId: string;
          senderNonce: string;
          ttl: number;
      }[]) => void), Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): (() => void)
    • Parameters

      • Rest ...args: [`ok_${string}`, ((queries: {
            fee: bigint;
            id: string;
            oracleId: string;
            query: string;
            response: string;
            responseTtl: { type: TTLType; value: string; };
            senderId: string;
            senderNonce: string;
            ttl: number;
        }[]) => void)] | [`ok_${string}`, ((queries: {
            fee: bigint;
            id: string;
            oracleId: string;
            query: string;
            response: string;
            responseTtl: { type: TTLType; value: string; };
            senderId: string;
            senderNonce: string;
            ttl: number;
        }[]) => void), Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns (() => void)

        • (): void
        • Poll for oracle queries

          Category

          oracle

          Returns

          Callback to stop polling function

          Returns void

pollForQueryResponse: ((...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

    • (...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<string>
    • Parameters

      • Rest ...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<string>

pool: Map<string, Node> = ...
postQueryToOracle: ((...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetQueryObjectReturnType>)

Type declaration

registerOracle: ((...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

resolveName: ((...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
    onNode: Node;
    resolveByNode?: boolean;
    verify?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>)

Type declaration

    • (...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
          onNode: Node;
          resolveByNode?: boolean;
          verify?: boolean;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>
    • Parameters

      • Rest ...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
            onNode: Node;
            resolveByNode?: boolean;
            verify?: boolean;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>

respondToQuery: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

selectedAddress?: `ak_${string}`
selectedNodeName?: string
send: ((...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

sendTransaction: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendTransactionReturnType>)

Type declaration

spend: ((...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>
    • Parameters

      • Rest ...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

transferFunds: ((...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

    • (...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<SendReturnType>
    • Parameters

      • Rest ...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<SendReturnType>

txDryRun: ((...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    txEvents?: {}[];
} & {
    callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
    reason?: string;
    result: string;
    type: string;
}>)

Type declaration

    • (...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
          combine?: boolean;
          onNode: Node;
          top?: number | `kh_${string}` | `mh_${string}`;
          txEvents?: boolean;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<{
          txEvents?: {}[];
      } & {
          callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
          reason?: string;
          result: string;
          type: string;
      }>
    • Parameters

      • Rest ...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
            combine?: boolean;
            onNode: Node;
            top?: number | `kh_${string}` | `mh_${string}`;
            txEvents?: boolean;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<{
          txEvents?: {}[];
      } & {
          callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
          reason?: string;
          result: string;
          type: string;
      }>

waitForTxConfirm: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    confirm?: number;
    onNode: Node;
} & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

    • (...args: [`th_${string}`] | [`th_${string}`, Omit<{
          confirm?: number;
          onNode: Node;
      } & {
          interval?: number;
          onNode: Node;
      } & {
          _expectedMineRate?: number;
          _maxPollInterval?: number;
          _microBlockCycle?: number;
      }, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: OnAccount;
          onCompiler?: CompilerBase;
          onNode?: Node;
      }]): Promise<number>
    • Parameters

      • Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
            confirm?: number;
            onNode: Node;
        } & {
            interval?: number;
            onNode: Node;
        } & {
            _expectedMineRate?: number;
            _maxPollInterval?: number;
            _microBlockCycle?: number;
        }, "onNode" | "onAccount" | "onCompiler"> & {
            onAccount?: OnAccount;
            onCompiler?: CompilerBase;
            onNode?: Node;
        }]

      Returns Promise<number>

Accessors

  • get address(): `ak_${string}`
  • Returns `ak_${string}`

Methods

  • Add specific account

    Example

    addAccount(account)
    

    Parameters

    • account: AccountBase

      Account instance

    • options: {
          select?: boolean;
      } = {}

      Options

      • Optional select?: boolean

        Select account

    Returns void

  • Add Node

    Example

    // add and select new node with name 'testNode'
    aeSdkBase.addNode('testNode', new Node({ url }), true)

    Parameters

    • name: string

      Node name

    • node: Node

      Node instance

    • select: boolean = false

      Select this node as current

    Returns void

  • Get accounts addresses

    Example

    addresses()
    

    Returns `ak_${string}`[]

  • Type Parameters

    • TxType extends Tag

    Parameters

    • txType: TxType
    • options: Omit<Omit<{
          tag: TxType;
          version?: Extract<KeysOfUnion<{
              10: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Account);
                      serialize: ((value?: Account) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["balance", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Account);
                      serialize: ((value?: Account) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["flags", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["balance", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["gaContract", {
                      deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                      serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["gaAuthFun", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              11: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => SignedTx);
                      serialize: ((value?: SignedTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["signatures", {
                      deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
                      serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
                  }], readonly ["encodedTx", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              12: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => SpendTx);
                      serialize: ((value?: SpendTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["senderId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["recipientId", {
                      deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                      serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["payload", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value?: `ba_${string}`) => Buffer);
                  }]];
              };
              20: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Oracle);
                      serialize: ((value?: Oracle) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["queryFormat", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["responseFormat", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["abiVersion", {
                      deserialize(buffer: Buffer): AbiVersion;
                      serialize(value: undefined | AbiVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                          tag: Tag;
                      }): Buffer;
                  }]];
              };
              22: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleRegisterTx);
                      serialize: ((value?: OracleRegisterTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["queryFormat", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["responseFormat", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["oracleTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["abiVersion", {
                      deserialize(buffer: Buffer): AbiVersion;
                      serialize(value: undefined | AbiVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                          tag: Tag;
                      }): Buffer;
                  }]];
              };
              23: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleQueryTx);
                      serialize: ((value?: OracleQueryTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["senderId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                      serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["query", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["queryFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["queryTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["queryTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["responseTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["responseTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              24: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleResponseTx);
                      serialize: ((value?: OracleResponseTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}`);
                      serialize: ((value: `ok_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["queryId", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `oq_${string}`) => Buffer);
                  }], readonly ["response", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["responseTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["responseTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              25: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OracleExtendTx);
                      serialize: ((value?: OracleExtendTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["oracleId", {
                      deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                      serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["oracleTtlType", {
                      deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                      serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
                  }], readonly ["oracleTtlValue", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              30: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Name);
                      serialize: ((value?: Name) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nameTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["status", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }], readonly ["clientTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["pointers", {
                      deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                      serialize(pointers: NamePointer[]): Buffer[][];
                  }]];
              };
              32: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameClaimTx);
                      serialize: ((value?: NameClaimTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["name", {
                      deserialize(value: Buffer): `${string}.chain`;
                      serialize(value: `${string}.chain`): Buffer;
                  }], readonly ["nameSalt", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["nameFee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, txFields: {
                          name: `${string}.chain`;
                      } & Options): Buffer;
                      serializeAettos(_value: undefined | string, txFields: {
                          name: `${string}.chain`;
                      }): string;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              33: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NamePreclaimTx);
                      serialize: ((value?: NamePreclaimTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["commitmentId", {
                      deserialize: ((value: Buffer) => `cm_${string}`);
                      serialize: ((value: `cm_${string}`) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              34: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameUpdateTx);
                      serialize: ((value?: NameUpdateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["nameTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["pointers", {
                      deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                      serialize(pointers: NamePointer[]): Buffer[][];
                  }], readonly ["clientTtl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              35: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameRevokeTx);
                      serialize: ((value?: NameRevokeTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              36: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameTransferTx);
                      serialize: ((value?: NameTransferTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accountId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nameId", {
                      deserialize: ((value: Buffer) => `nm_${string}`);
                      serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
                  }], readonly ["recipientId", {
                      deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                      serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              40: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Contract);
                      serialize: ((value?: Contract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["owner", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["ctVersion", {
                      deserialize(buffer: Buffer): CtVersion;
                      serialize(value: undefined | CtVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                      }): Buffer;
                  }], readonly ["code", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["log", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["active", {
                      deserialize(buffer: Buffer): boolean;
                      serialize(value: boolean): Buffer;
                  }], readonly ["referers", {
                      deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
                      serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
                  }], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, options: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }]];
              };
              41: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCall);
                      serialize: ((value?: ContractCall) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["callerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["callerNonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["height", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["contractId", {
                      deserialize: ((value: Buffer) => `ct_${string}`);
                      serialize: ((value: `ct_${string}`) => Buffer);
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["gasUsed", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["returnValue", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["returnType", {
                      deserialize: ((value: Buffer) => CallReturnType);
                      serialize: ((value: CallReturnType) => Buffer);
                  }], readonly ["log", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }]];
              };
              42: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCreateTx);
                      serialize: ((value?: ContractCreateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["ownerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["code", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["ctVersion", {
                      deserialize(buffer: Buffer): CtVersion;
                      serialize(value: undefined | CtVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                      }): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, options: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              43: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractCallTx);
                      serialize: ((value?: ContractCallTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["callerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["contractId", {
                      deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                      serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
                  }], readonly ["abiVersion", {
                      deserialize(buffer: Buffer): AbiVersion;
                      serialize(value: undefined | AbiVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                          tag: Tag;
                      }): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              50: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCreateTx);
                      serialize: ((value?: ChannelCreateTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["initiator", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responder", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["responderAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["channelReserve", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockPeriod", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["initiatorDelegateIds", {
                      deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
                  }], readonly ["responderDelegateIds", {
                      deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              51: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelDepositTx);
                      serialize: ((value?: ChannelDepositTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              52: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelWithdrawTx);
                      serialize: ((value?: ChannelWithdrawTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["toId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              521: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelForceProgressTx);
                      serialize: ((value?: ChannelForceProgressTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `tx_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["update", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }], readonly ["offChainTrees", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `ss_${string}`) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              53: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                      serialize: ((value?: ChannelCloseMutualTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              54: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                      serialize: ((value?: ChannelCloseSoloTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `tx_${string}`) => Buffer);
                  }], readonly ["poi", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              55: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSlashTx);
                      serialize: ((value?: ChannelSlashTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `tx_${string}`) => Buffer);
                  }], readonly ["poi", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              56: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSettleTx);
                      serialize: ((value?: ChannelSettleTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["initiatorAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmountFinal", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              57: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainTx);
                      serialize: ((value?: ChannelOffChainTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }]];
              };
              570: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                      serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["to", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              571: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                      serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              572: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                      serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["from", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }]];
              };
              573: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                      serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["owner", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["ctVersion", {
                      deserialize(buffer: Buffer): CtVersion;
                      serialize(value: undefined | CtVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                      }): Buffer;
                  }], readonly ["code", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["deposit", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["callData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              574: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                      serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["caller", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["contract", {
                      deserialize: ((value: Buffer) => `ct_${string}`);
                      serialize: ((value: `ct_${string}`) => Buffer);
                  }], readonly ["abiVersion", {
                      deserialize(buffer: Buffer): AbiVersion;
                      serialize(value: undefined | AbiVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                          tag: Tag;
                      }): Buffer;
                  }], readonly ["amount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["callData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["callStack", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }]];
              };
              575: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                      serialize: ((value?: ChannelClientReconnectTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["role", {
                      deserialize(buffer: Buffer): string;
                      serialize(string: string): Buffer;
                  }], readonly ["pubkey", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }]];
              };
              58: {
                  3: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Channel);
                      serialize: ((value?: Channel) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 3);
                      serialize: ((value?: 3) => Buffer);
                  }], readonly ["initiator", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["responder", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["channelAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["responderAmount", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["channelReserve", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorDelegateIds", {
                      deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
                  }], readonly ["responderDelegateIds", {
                      deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                      serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
                  }], readonly ["stateHash", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `st_${string}`) => Buffer);
                  }], readonly ["round", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["soloRound", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockPeriod", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["lockedUntil", {
                      deserialize(value: Buffer): string;
                      serialize(value: Int): Buffer;
                  }], readonly ["initiatorAuth", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["responderAuth", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              59: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                      serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channelId", {
                      deserialize: ((value: Buffer) => `ch_${string}`);
                      serialize: ((value: `ch_${string}`) => Buffer);
                  }], readonly ["fromId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["payload", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `tx_${string}`) => Buffer);
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }]];
              };
              60: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => TreesPoi);
                      serialize: ((value?: TreesPoi) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accounts", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
                      serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
                  }], readonly ["calls", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
                      serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
                  }], readonly ["channels", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
                      serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
                  }], readonly ["contracts", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
                      serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
                  }], readonly ["ns", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
                      serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
                  }], readonly ["oracles", {
                      deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
                      serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
                  }]];
              };
              62: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => StateTrees);
                      serialize: ((value?: StateTrees) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["contracts", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["calls", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["channels", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["ns", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["oracles", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }], readonly ["accounts", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              621: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ContractsMtree);
                      serialize: ((value?: ContractsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["contracts", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              622: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => CallsMtree);
                      serialize: ((value?: CallsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["calls", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              623: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => ChannelsMtree);
                      serialize: ((value?: ChannelsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["channels", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              624: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => NameserviceMtree);
                      serialize: ((value?: NameserviceMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["mtree", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              625: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => OraclesMtree);
                      serialize: ((value?: OraclesMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["otree", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              626: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => AccountsMtree);
                      serialize: ((value?: AccountsMtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["accounts", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              63: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => Mtree);
                      serialize: ((value?: Mtree) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["values", {
                      deserialize: ((value: Buffer[], params: unknown) => any[]);
                      serialize: ((value: any[], params: unknown) => Buffer[]);
                  }]];
              };
              64: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => MtreeValue);
                      serialize: ((value?: MtreeValue) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["key", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }], readonly ["value", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }]];
              };
              80: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => GaAttachTx);
                      serialize: ((value?: GaAttachTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["ownerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["code", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["authFun", {
                      deserialize(buffer: Buffer): Buffer;
                      serialize(buffer: Uint8Array): Buffer;
                  }], readonly ["ctVersion", {
                      deserialize(buffer: Buffer): CtVersion;
                      serialize(value: undefined | CtVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                      }): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["ttl", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["callData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }]];
              };
              81: {
                  2: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => GaMetaTx);
                      serialize: ((value?: GaMetaTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 2);
                      serialize: ((value?: 2) => Buffer);
                  }], readonly ["gaId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["authData", {
                      deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                      serialize: ((value: `cb_${string}`) => Buffer);
                  }], readonly ["abiVersion", {
                      deserialize(buffer: Buffer): AbiVersion;
                      serialize(value: undefined | AbiVersion, __namedParameters: {
                          consensusProtocolVersion: Iris;
                          tag: Tag;
                      }): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["gasLimit", {
                      deserialize(value: Buffer): number;
                      serialize(_value: undefined | number, __namedParameters: {
                          _computingGasLimit?: number;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          gasMax: number;
                          rebuildTx: ((params: any) => any);
                          tag: Tag;
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): Buffer;
                  }], readonly ["gasPrice", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(value?: undefined | string): string;
                  }], readonly ["tx", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
              82: {
                  1: readonly [readonly ["tag", {
                      deserialize: ((value: Buffer) => PayingForTx);
                      serialize: ((value?: PayingForTx) => Buffer);
                  }], readonly ["version", {
                      deserialize: ((value: Buffer) => 1);
                      serialize: ((value?: 1) => Buffer);
                  }], readonly ["payerId", {
                      deserialize: ((value: Buffer) => `ak_${string}`);
                      serialize: ((value: `ak_${string}`) => Buffer);
                  }], readonly ["nonce", {
                      deserialize(value: Buffer): number;
                      serialize(value: number): Buffer;
                  }], readonly ["fee", {
                      deserialize(value: Buffer): string;
                      serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                      serializeAettos(_value: undefined | string, __namedParameters: {
                          _computingMinFee?: BigNumber;
                          _pickBiggerFee?: boolean;
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                          rebuildTx: ((params: any) => `tx_${string}`);
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }): string;
                  }], readonly ["tx", {
                      deserialize: ((value: Buffer, options: {
                          unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                      }) => any);
                      serialize: ((value: any, options: {
                          buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                              gasMax?: number;
                          } : {}), options?: {
                              denomination?: AE_AMOUNT_FORMATS;
                              prefix?: E;
                          }) => Generic<E>);
                      }) => Buffer);
                  }]];
              };
          }[TxType]>, number>;
      } & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
          10: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["flags", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["gaContract", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["gaAuthFun", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          11: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SignedTx);
                  serialize: ((value?: SignedTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["signatures", {
                  deserialize: ((value: Buffer[], params: unknown) => Buffer[]);
                  serialize: ((value: Uint8Array[], params: unknown) => Buffer[]);
              }], readonly ["encodedTx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          12: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SpendTx);
                  serialize: ((value?: SpendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value?: `ba_${string}`) => Buffer);
              }]];
          };
          20: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Oracle);
                  serialize: ((value?: Oracle) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["queryFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }]];
          };
          22: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleRegisterTx);
                  serialize: ((value?: OracleRegisterTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseFormat", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }]];
          };
          23: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleQueryTx);
                  serialize: ((value?: OracleQueryTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["query", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["queryTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["queryTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          24: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleResponseTx);
                  serialize: ((value?: OracleResponseTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}`);
                  serialize: ((value: `ok_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryId", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `oq_${string}`) => Buffer);
              }], readonly ["response", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          25: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleExtendTx);
                  serialize: ((value?: OracleExtendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          30: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Name);
                  serialize: ((value?: Name) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["status", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }]];
          };
          32: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameClaimTx);
                  serialize: ((value?: NameClaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["name", {
                  deserialize(value: Buffer): `${string}.chain`;
                  serialize(value: `${string}.chain`): Buffer;
              }], readonly ["nameSalt", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nameFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, txFields: {
                      name: `${string}.chain`;
                  } & Options): Buffer;
                  serializeAettos(_value: undefined | string, txFields: {
                      name: `${string}.chain`;
                  }): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          33: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NamePreclaimTx);
                  serialize: ((value?: NamePreclaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["commitmentId", {
                  deserialize: ((value: Buffer) => `cm_${string}`);
                  serialize: ((value: `cm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          34: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameUpdateTx);
                  serialize: ((value?: NameUpdateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          35: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameRevokeTx);
                  serialize: ((value?: NameRevokeTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          36: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameTransferTx);
                  serialize: ((value?: NameTransferTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          40: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Contract);
                  serialize: ((value?: Contract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["log", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["active", {
                  deserialize(buffer: Buffer): boolean;
                  serialize(value: boolean): Buffer;
              }], readonly ["referers", {
                  deserialize: ((value: Buffer[], params: unknown) => `ak_${string}`[]);
                  serialize: ((value: `ak_${string}`[], params: unknown) => Buffer[]);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }]];
          };
          41: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCall);
                  serialize: ((value?: ContractCall) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["callerNonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["height", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasUsed", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["returnValue", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["returnType", {
                  deserialize: ((value: Buffer) => CallReturnType);
                  serialize: ((value: CallReturnType) => Buffer);
              }], readonly ["log", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }]];
          };
          42: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCreateTx);
                  serialize: ((value?: ContractCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          43: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCallTx);
                  serialize: ((value?: ContractCallTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          50: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCreateTx);
                  serialize: ((value?: ChannelCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          51: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelDepositTx);
                  serialize: ((value?: ChannelDepositTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          52: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelWithdrawTx);
                  serialize: ((value?: ChannelWithdrawTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["toId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          521: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelForceProgressTx);
                  serialize: ((value?: ChannelForceProgressTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["update", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["offChainTrees", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `ss_${string}`) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          53: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                  serialize: ((value?: ChannelCloseMutualTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          54: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                  serialize: ((value?: ChannelCloseSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          55: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSlashTx);
                  serialize: ((value?: ChannelSlashTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          56: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSettleTx);
                  serialize: ((value?: ChannelSettleTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          57: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainTx);
                  serialize: ((value?: ChannelOffChainTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }]];
          };
          570: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                  serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["to", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          571: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                  serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          572: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                  serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          573: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                  serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          574: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                  serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["caller", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["contract", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["callStack", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }]];
          };
          575: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                  serialize: ((value?: ChannelClientReconnectTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["role", {
                  deserialize(buffer: Buffer): string;
                  serialize(string: string): Buffer;
              }], readonly ["pubkey", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }]];
          };
          58: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Channel);
                  serialize: ((value?: Channel) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["channelAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[], params: unknown) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[], params: unknown) => Buffer[]);
              }], readonly ["stateHash", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `st_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["soloRound", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockedUntil", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAuth", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["responderAuth", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          59: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                  serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `tx_${string}`) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          60: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => TreesPoi);
                  serialize: ((value?: TreesPoi) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<AccountAddress, Account>[]);
                  serialize: ((value: MPTree<AccountAddress, Account>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["calls", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Bytearray, ContractCall>[]);
                  serialize: ((value: MPTree<Bytearray, ContractCall>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["channels", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Channel, Channel>[]);
                  serialize: ((value: MPTree<Channel, Channel>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["contracts", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<ContractAddress, Contract>[]);
                  serialize: ((value: MPTree<ContractAddress, Contract>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["ns", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<Name, Name>[]);
                  serialize: ((value: MPTree<Name, Name>[], params: unknown) => MPTreeBinary[]);
              }], readonly ["oracles", {
                  deserialize: ((value: MPTreeBinary[], params: unknown) => MPTree<OracleAddress, Oracle>[]);
                  serialize: ((value: MPTree<OracleAddress, Oracle>[], params: unknown) => MPTreeBinary[]);
              }]];
          };
          62: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => StateTrees);
                  serialize: ((value?: StateTrees) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["calls", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["channels", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ns", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["oracles", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          621: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractsMtree);
                  serialize: ((value?: ContractsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          622: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CallsMtree);
                  serialize: ((value?: CallsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["calls", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          623: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelsMtree);
                  serialize: ((value?: ChannelsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channels", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          624: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameserviceMtree);
                  serialize: ((value?: NameserviceMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["mtree", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          625: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OraclesMtree);
                  serialize: ((value?: OraclesMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["otree", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          626: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => AccountsMtree);
                  serialize: ((value?: AccountsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          63: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Mtree);
                  serialize: ((value?: Mtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["values", {
                  deserialize: ((value: Buffer[], params: unknown) => any[]);
                  serialize: ((value: any[], params: unknown) => Buffer[]);
              }]];
          };
          64: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => MtreeValue);
                  serialize: ((value?: MtreeValue) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["key", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["value", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }]];
          };
          80: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaAttachTx);
                  serialize: ((value?: GaAttachTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["authFun", {
                  deserialize(buffer: Buffer): Buffer;
                  serialize(buffer: Uint8Array): Buffer;
              }], readonly ["ctVersion", {
                  deserialize(buffer: Buffer): CtVersion;
                  serialize(value: undefined | CtVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }]];
          };
          81: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaMetaTx);
                  serialize: ((value?: GaMetaTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["gaId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["authData", {
                  deserialize: ((value: Buffer) => `kh_${string}` | `mh_${string}` | `bf_${string}` | `bx_${string}` | `bs_${string}` | `ch_${string}` | `ct_${string}` | `cb_${string}` | `ck_${string}` | `cv_${string}` | `tx_${string}` | `th_${string}` | `ok_${string}` | `ov_${string}` | `oq_${string}` | `or_${string}` | `ak_${string}` | `sg_${string}` | `cm_${string}` | `pp_${string}` | `nm_${string}` | `st_${string}` | `pi_${string}` | `ss_${string}` | `cs_${string}` | `ba_${string}`);
                  serialize: ((value: `cb_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize(buffer: Buffer): AbiVersion;
                  serialize(value: undefined | AbiVersion, __namedParameters: {
                      consensusProtocolVersion: Iris;
                      tag: Tag;
                  }): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["tx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
          82: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => PayingForTx);
                  serialize: ((value?: PayingForTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["payerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["tx", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => RawTxObject<TxTypeSchemas[TxType]>);
                  }) => any);
                  serialize: ((value: any, options: {
                      buildTx: (<TxType, E, Version>(params: {
                          tag: TxType;
                          version?: Version;
                      } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }]];
          };
      }[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
          gasMax?: number;
      } : {}), "nonce" | "ttl" | "tag"> & {
          absoluteTtl?: boolean;
          denomination?: AE_AMOUNT_FORMATS;
          nonce?: number;
          onNode: Node;
          strategy?: "max" | "continuity";
          ttl?: number;
      } & (TxType extends OracleResponseTx | OracleExtendTx ? {
          callerId: `ak_${string}`;
      } : {}), "onNode"> & {
          onNode?: Node;
      }

    Returns Promise<`tx_${string}`>

  • Type Parameters

    Parameters

    • Optional options: Omit<Omit<{
          aci: Aci;
          address?: `ct_${string}`;
          bytecode?: `cb_${string}`;
          fileSystem?: Record<string, string>;
          onCompiler?: CompilerBase;
          onNode: Node;
          sourceCode?: string;
          sourceCodePath?: string;
      } & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
          omitUnknown?: boolean;
      } & {
          contractAddressToName?: {
              [key: ContractAddress]: string;
          };
      } & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
          combine?: boolean;
          onNode: Node;
          top?: number | `kh_${string}` | `mh_${string}`;
          txEvents?: boolean;
      }, "onNode"> & {
          callStatic?: boolean;
          onAccount?: AccountBase;
          onNode?: Node;
      } & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
          aci?: Aci;
          address?: `${string}.chain` | `ct_${string}`;
          validateBytecode?: boolean;
      }, "onNode"> & {
          onNode?: Node;
      }

    Returns Promise<Contract<Methods>>

  • Remove specific account

    Example

    removeAccount(address)
    

    Parameters

    • address: `ak_${string}`

      Address of account to remove

    Returns void

  • Select specific account

    Example

    selectAccount('ak_xxxxxxxx')
    

    Parameters

    • address: `ak_${string}`

      Address of account to select

    Returns void

  • Select Node

    Example

    nodePool.selectNode('testNode')
    

    Parameters

    • name: string

      Node name

    Returns void

  • Parameters

    • data: string | Uint8Array
    • __namedParameters: {
          onAccount?: OnAccount;
      } = {}

    Returns Promise<Uint8Array>

  • Parameters

    • message: string
    • __namedParameters: {
          onAccount?: OnAccount;
      } & {
          aeppOrigin?: string;
          aeppRpcClientId?: string;
      } = {}

    Returns Promise<Uint8Array>

  • Parameters

    • tx: `tx_${string}`
    • __namedParameters: {
          onAccount?: OnAccount;
      } & {
          aeppOrigin?: string;
          aeppRpcClientId?: string;
          authData?: {
              args?: any[];
              callData?: `cb_${string}`;
              gasLimit?: number;
              sourceCode?: string;
          };
          innerTx?: boolean;
          networkId?: string;
          onCompiler?: CompilerBase;
          onNode?: Node;
      } = {}

    Returns Promise<`tx_${string}`>

Generated using TypeDoc